home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 …ember: Reference Library / Dev.CD Dec 00 RL Disk 1.toast / pc / technical documentation / develop / develop issue 26 / develop issue 26 code / truffles - display mgr. / sprocket / sources / dynamicarray.cp < prev    next >
Encoding:
Text File  |  1996-01-02  |  3.3 KB  |  195 lines
  1. /*
  2.     File:        DynamicArray.cp
  3.  
  4.     Contains:    A handle-based dynamic array class
  5.                 
  6.     Written by: Dave Falkenburg
  7.     
  8.     Copyright:    © 1994-95 by Dave Falkenburg, all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.      
  12.          <1>      1/3/95    DRF        First checked in.
  13.  */
  14.  
  15. #include "DynamicArray.h"
  16. #include <Memory.h>
  17.  
  18. TDynamicArray::TDynamicArray()
  19.     {
  20.     fElementCount = 0;
  21.     fStorage = (ArrayElementPtr **) NewHandle(0);
  22.     }
  23.     
  24.  
  25. TDynamicArray::~TDynamicArray()
  26.     {
  27.     DisposeHandle((Handle) fStorage);
  28.     }
  29.  
  30.  
  31. OSErr
  32. TDynamicArray::InsertFirst(ArrayElement * elementToInsert)
  33.     {
  34.     return this->Insert(elementToInsert,0);
  35.     }
  36.  
  37.  
  38. OSErr
  39. TDynamicArray::InsertLast(ArrayElement * elementToInsert)
  40.     {
  41.     return this->Insert(elementToInsert,fElementCount);
  42.     }
  43.  
  44.  
  45.     
  46.  
  47. OSErr
  48. TDynamicArray::Insert(ArrayElement * elementToInsert, ArrayElementIndex beforeElement)
  49.     {
  50.     OSErr    err;
  51.     
  52.     //    make room for one more ArrayElementPtr
  53.     SetHandleSize((Handle) fStorage, fElementCount*sizeof(ArrayElementPtr) + sizeof(ArrayElementPtr));
  54.     if ((err = MemError()) != noErr)
  55.         return err;
  56.     
  57.     //    slide remaining elements down
  58.     
  59.     if (fElementCount)
  60.         {
  61.         BlockMoveData(    &((*fStorage)[beforeElement]),
  62.                         &((*fStorage)[beforeElement+1]),
  63.                         (fElementCount - beforeElement) * sizeof(ArrayElementPtr));
  64.         }
  65.     
  66.     fElementCount++;
  67.     (*fStorage)[beforeElement] = elementToInsert;
  68.  
  69.     return noErr;
  70.     }
  71.  
  72.  
  73.  
  74. OSErr
  75. TDynamicArray::Delete(ArrayElementPtr elementToDelete)
  76.     {
  77.     ArrayElementIndex index;
  78.     
  79.     for (index=0; index < fElementCount; index++)
  80.         {
  81.         if (elementToDelete == (*fStorage)[index])
  82.             return this->DeleteElementGivenIndex(index);
  83.         }
  84.  
  85.     return -1;
  86.     }
  87.  
  88.  
  89. OSErr
  90. TDynamicArray::DeleteFirst()
  91.     {
  92.     return this->DeleteElementGivenIndex(0);
  93.     }
  94.  
  95.  
  96. OSErr
  97. TDynamicArray::DeleteLast()
  98.     {
  99.     return this->DeleteElementGivenIndex(fElementCount-1);
  100.     }
  101.  
  102.  
  103. OSErr
  104. TDynamicArray::DeleteElementGivenIndex(ArrayElementIndex whichElement)
  105.     {
  106.     if (whichElement > fElementCount)
  107.         return -1;
  108.         
  109.     //    CHECK THE MATH, DAVE!
  110.  
  111.     if (fElementCount)
  112.         {
  113.         //    slide remaining elements up
  114.  
  115.         BlockMoveData(    &((*fStorage)[whichElement+1]),
  116.                         &((*fStorage)[whichElement]),
  117.                         (fElementCount - whichElement) * sizeof(ArrayElementPtr));
  118.  
  119.         //    cut back the storage
  120.         fElementCount--;
  121.         SetHandleSize((Handle) fStorage,fElementCount*sizeof(ArrayElementPtr));
  122.     
  123.         return noErr;
  124.         }
  125.     else
  126.         return -1;
  127.     }
  128.  
  129.  
  130. OSErr
  131. TDynamicArray::MoveToFront(ArrayElementPtr elementToMove)
  132.     {
  133.     ArrayElementIndex index;
  134.  
  135.     for (index=0; index < fElementCount; index++)
  136.         {
  137.         if (elementToMove == (*fStorage)[index])
  138.             {
  139.             if (index != 0)
  140.                 {
  141.                 BlockMove(&(*fStorage)[0],&(*fStorage)[1],index*sizeof(ArrayElementPtr));
  142.                 (*fStorage)[0] = elementToMove;
  143.                 }
  144.             return 0;
  145.             }
  146.         }
  147.  
  148.     return -1;
  149.     }
  150.  
  151.  
  152. void
  153. TDynamicArray::ForEachElement(EachArrayElementProc proc, void * param)
  154.     {
  155.     ArrayElementIndex    index = 0;
  156.     
  157.     while (index < fElementCount)
  158.         {
  159.         (*proc)((*fStorage)[index],param);
  160.         index++;
  161.         }
  162.     }
  163.  
  164.  
  165. ArrayElement *
  166. TDynamicArray::FirstElementThat(EachArrayElementTestProc proc, void * param)
  167.     {
  168.     ArrayElementIndex    index = 0;
  169.         
  170.     while (index < fElementCount)
  171.         {
  172.         if ((*proc)((*fStorage)[index],param))
  173.             return (*fStorage)[index];
  174.         index++;
  175.         }
  176.  
  177.     return NULL;
  178.     }
  179.  
  180.  
  181. ArrayElement *
  182. TDynamicArray::LastElementThat(EachArrayElementTestProc proc, void * param)
  183.     {
  184.     ArrayElementIndex    index = fElementCount-1;
  185.     
  186.     while (index != -1)
  187.         {
  188.         if ((*proc)((*fStorage)[index],param))
  189.             return (*fStorage)[index];
  190.         index--;
  191.         }
  192.  
  193.     return NULL;
  194.     }
  195.